SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Declarative programming</title>

</head>

<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Declarative programming</span></span>

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1248332772">

/* start https://en.wikipedia.org/ */

.mw-parser-output .multiple-issues-text{width:95%;margin:0.2em 0}.mw-parser-output .multiple-issues-text>.mw-collapsible-content{margin-top:0.3em}.mw-parser-output .compact-ambox .ambox{border:none;border-collapse:collapse;background-color:transparent;margin:0 0 0 1.6em!important;padding:0!important;width:auto;display:block}body.mediawiki .mw-parser-output .compact-ambox .ambox.mbox-small-left{font-size:100%;width:auto;margin:0}.mw-parser-output .compact-ambox .ambox .mbox-text{padding:0!important;margin:0!important}.mw-parser-output .compact-ambox .ambox .mbox-text-span{display:list-item;line-height:1.5em;list-style-type:disc}body.skin-minerva .mw-parser-output .multiple-issues-text>.mw-collapsible-toggle,.mw-parser-output .compact-ambox .ambox .mbox-image,.mw-parser-output .compact-ambox .ambox .mbox-imageright,.mw-parser-output .compact-ambox .ambox .mbox-empty-cell,.mw-parser-output .compact-ambox .hide-when-compact{display:none}

/* end https://en.wikipedia.org/ */

</style>

<p>In <a href="Computer_science" title="Computer science">computer science</a>, <b>declarative programming</b> is a <a href="Programming_paradigm" title="Programming paradigm">programming paradigm</a>, a style of building the structure and elements of computer programs, that expresses the logic of a <a href="Computation" title="Computation">computation</a> without describing its <a href="Control_flow" title="Control flow">control flow</a>.<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>

</p><p>Many languages that apply this style attempt to minimize or eliminate <a href="Side_effect_(computer_science)" title="Side effect (computer science)">side effects</a> by describing <i>what</i> the program must accomplish in terms of the <a href="Domain_knowledge" title="Domain knowledge">problem domain</a>, rather than describing <i>how</i> to accomplish it as a sequence of the programming <a href="Language_primitive" title="Language primitive">language primitives</a><sup id="cite_ref-FOLDOC_2004_2-0" class="reference"><a href="#cite_note-FOLDOC_2004-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> (the <i>how</i> being left up to the language's <a href="Programming_language_implementation" title="Programming language implementation">implementation</a>). This is in contrast with <a href="Imperative_programming" title="Imperative programming">imperative programming</a>, which implements <a href="Algorithm" title="Algorithm">algorithms</a> in explicit steps.<sup id="cite_ref-Sebesta_2016_3-0" class="reference"><a href="#cite_note-Sebesta_2016-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>

</p><p>Declarative programming often considers <a href="Program_(machine)" title="Program (machine)">programs</a> as theories of a <a href="Mathematical_logic#Formal_logical_systems" title="Mathematical logic">formal logic</a>, and computations as deductions in that logic space. Declarative programming may greatly simplify writing <a href="Parallel_computing" title="Parallel computing">parallel programs</a>.<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>

</p><p>Common declarative languages include those of <a href="Query_languages" class="mw-redirect" title="Query languages">database query languages</a> (e.g., <a href="SQL" title="SQL">SQL</a>, <a href="XQuery" title="XQuery">XQuery</a>), <a href="Regular_expression" title="Regular expression">regular expressions</a>, <a href="Logic_programming" title="Logic programming">logic programming</a> (e.g., <a href="Prolog" title="Prolog">Prolog</a>, <a href="Datalog" title="Datalog">Datalog</a>, <a href="Answer_set_programming" title="Answer set programming">answer set programming</a>), <a href="Functional_programming" title="Functional programming">functional programming</a>, <a href="Configuration_management_database" title="Configuration management database">configuration management</a>, and <a href="Algebraic_modeling_language" title="Algebraic modeling language">algebraic modeling</a> systems.

</p>

<div class="mw-heading mw-heading2"><h2 id="Definition">Definition</h2></div>

<p>Declarative programming is often defined as any style of programming that is not imperative. A number of other common definitions attempt to define it by simply contrasting it with imperative programming. For example:

</p>

<ul><li>A high-level program that describes what a computation should perform.</li>

<li>Any programming language that lacks <a href="Side_effect_(computer_science)" title="Side effect (computer science)">side effects</a>, or more specifically, has <a href="Referential_transparency" title="Referential transparency">referential transparency</a>.</li>

<li>A language with a clear correspondence to <a href="Mathematical_logic" title="Mathematical logic">mathematical logic</a>.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup></li></ul>

<p>These definitions overlap substantially.

</p><p>Declarative programming is a non-imperative style of programming in which programs describe their desired results without explicitly listing commands or steps that must be performed. Functional and logic programming languages are characterized by a declarative programming style. In logic programming, programs consist of sentences expressed in logical form, and computation uses those sentences to solve problems, which are also expressed in logical form.

</p><p>In a <a href="Pure_functional_language" class="mw-redirect" title="Pure functional language">pure functional language</a>, such as <a href="Haskell" title="Haskell">Haskell</a>, all functions are <a href="Pure_function" title="Pure function">without side effects</a>, and state changes are only represented as functions that transform the state, which is explicitly represented as a <a href="First-class_citizen" title="First-class citizen">first-class</a> object in the program. Although pure functional languages are non-imperative, they often provide a facility for describing the effect of a function as a series of steps. Other functional languages, such as <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a>, <a href="OCaml" title="OCaml">OCaml</a> and <a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a>, support a mixture of procedural and functional programming.

</p><p>Some logic programming languages, such as <a href="Prolog" title="Prolog">Prolog</a>, and database query languages, such as SQL, while declarative in principle, also support a procedural style of programming.

</p>

<div class="mw-heading mw-heading2"><h2 id="Subparadigms">Subparadigms</h2></div>

<p>Declarative programming is an <a href="Umbrella_term" class="mw-redirect" title="Umbrella term">umbrella term</a> that includes a number of better-known <a href="Programming_paradigm" title="Programming paradigm">programming paradigms</a>.

</p>

<div class="mw-heading mw-heading3"><h3 id="Constraint_programming">Constraint programming</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Constraint_programming" title="Constraint programming">Constraint programming</a></div>

<p>Constraint programming states relations between variables in the form of constraints that specify the properties of the target solution. The set of constraints is <a href="Solver_(computer_science)" class="mw-redirect" title="Solver (computer science)">solved</a> by giving a value to each variable so that the solution is consistent with the maximum number of constraints. Constraint programming often complements other paradigms: functional, logical, or even imperative programming.

</p>

<div class="mw-heading mw-heading3"><h3 id="Domain-specific_languages">Domain-specific languages</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Domain-specific_language" title="Domain-specific language">Domain-specific language</a></div>

<p>Well-known examples of declarative domain-specific languages (DSLs) include the <a href="Yacc" title="Yacc">yacc</a> parser generator input language, <a href="QML" title="QML">QML</a>, the <a href="Make_(software)" title="Make (software)">Make</a> build specification language, <a href="Puppet_(software)" title="Puppet (software)">Puppet</a>'s configuration management language, <a href="Regular_expression" title="Regular expression">regular expressions</a>, <a href="Datalog" title="Datalog">Datalog</a>, <a href="Answer_set_programming" title="Answer set programming">answer set programming</a> and a subset of <a href="SQL" title="SQL">SQL</a> (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be <a href="Turing-complete" class="mw-redirect" title="Turing-complete">Turing-complete</a>, which makes it easier for a language to be purely declarative.

</p><p>Many markup languages such as <a href="HTML" title="HTML">HTML</a>, <a href="MXML" title="MXML">MXML</a>, <a href="XAML" class="mw-redirect" title="XAML">XAML</a>, <a href="XSLT" title="XSLT">XSLT</a> or other <a href="User-interface_markup_language" class="mw-redirect" title="User-interface markup language">user-interface markup languages</a> are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies neither <a href="Control_flow" title="Control flow">control flow</a> for rendering a page nor the page's possible <a href="Human-computer_interaction" class="mw-redirect" title="Human-computer interaction">interactions with a user</a>.

</p><p>As of 2013, some software systems combine traditional user-interface markup languages (such as HTML) with declarative markup that defines what (but not how) the <a href="Frontend_and_backend" title="Frontend and backend">back-end</a> server systems should do to support the declared interface. Such systems, typically using a domain-specific <a href="XML_namespace" title="XML namespace">XML namespace</a>, may include abstractions of SQL database syntax or parameterized calls to web services using <a href="Representational_state_transfer" class="mw-redirect" title="Representational state transfer">representational state transfer</a> (REST) and <a href="SOAP" title="SOAP">SOAP</a>.

</p>

<div class="mw-heading mw-heading3"><h3 id="Functional_programming">Functional programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Functional_programming" title="Functional programming">Functional programming</a></div>

<p>Functional programming languages such as <a href="Haskell" title="Haskell">Haskell</a>, <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a>, and <a href="ML_(programming_language)" title="ML (programming language)">ML</a> evaluate expressions via function application. Unlike the related but more imperative paradigm of <a href="Procedural_programming" title="Procedural programming">procedural programming</a>, functional programming places little emphasis on explicit sequencing. Instead, computations are characterised by various kinds of recursive <a href="Higher-order_function" title="Higher-order function">higher-order function</a> application and <a href="Function_composition_(computer_science)" title="Function composition (computer science)">composition</a>, and as such can be regarded simply as a set of mappings between <a href="Domain_of_a_function" title="Domain of a function">domains</a> and <a href="Codomain" title="Codomain">codomains</a>. Many functional languages, including most of those in the ML and Lisp families, are not <a href="Purely_functional_programming" title="Purely functional programming">purely functional</a>, and thus allow introducing <a href="Side_effect_(computer_science)" title="Side effect (computer science)">stateful effects</a> in programs.

</p>

<div class="mw-heading mw-heading3"><h3 id="Hybrid_languages">Hybrid languages</h3></div>

<div role="note" class="hatnote navigation-not-searchable">See also: <a href="Multi-paradigm_programming_language" class="mw-redirect" title="Multi-paradigm programming language">Multi-paradigm programming language</a></div>

<p>Makefiles, for example, specify dependencies in a declarative fashion,<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> but include an imperative list of actions to take as well. Similarly, yacc specifies a context free grammar declaratively, but includes code snippets from a host language, which is usually imperative (such as <a href="C_(programming_language)" title="C (programming language)">C</a>).

</p>

<div class="mw-heading mw-heading3"><h3 id="Logic_programming">Logic programming</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Logic_programming" title="Logic programming">Logic programming</a></div>

<p>Logic programming languages, such as <a href="Prolog" title="Prolog">Prolog</a>, <a href="Datalog" title="Datalog">Datalog</a> and <a href="Answer_set_programming" title="Answer set programming">answer set programming</a>, compute by proving that a goal is a logical consequence of the program, or by showing that the goal is true in a model defined by the program. Prolog computes by reducing goals to subgoals, top-down using <a href="Backward_chaining" title="Backward chaining">backward reasoning</a>, whereas most Datalog systems compute bottom-up using <a href="Forward_chaining" title="Forward chaining">forward reasoning</a>. Answer set programs typically use <a href="Boolean_SAT_solver" class="mw-redirect" title="Boolean SAT solver">SAT solvers</a> to generate a model of the program.

</p>

<div class="mw-heading mw-heading3"><h3 id="Modeling">Modeling</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Mathematical_model" title="Mathematical model">Mathematical model</a></div>

<p>Models, or mathematical representations, of physical systems may be implemented in computer code that is declarative. The code contains a number of equations, not imperative assignments, that describe ("declare") the behavioral relationships. When a model is expressed in this formalism, a computer is able to perform algebraic manipulations to best formulate the solution algorithm. The mathematical causality is typically imposed at the boundaries of the physical system, while the behavioral description of the system itself is declarative or acausal. Declarative <a href="Modeling_language" title="Modeling language">modeling languages</a> and environments include <a href="Analytica_(software)" title="Analytica (software)">Analytica</a>, <a href="Modelica" title="Modelica">Modelica</a> and Simile.<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>

<p><a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a> is a family of programming languages loosely inspired by mathematical notation and <a href="Alonzo_Church" title="Alonzo Church">Alonzo Church</a>'s <a href="Lambda_calculus" title="Lambda calculus">lambda calculus</a>. Some dialects, such as <a href="Common_Lisp" title="Common Lisp">Common Lisp</a>, are primarily imperative but support functional programming. Others, such as <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a>, are designed for functional programming.

</p><p>In Scheme, the <a href="Factorial" title="Factorial">factorial</a> function can be defined as follows:

</p>

<div class="mw-highlight mw-highlight-lang-scheme mw-content-ltr" dir="ltr"><pre><span class="p">(</span><span class="k">define</span><span class="w"> </span><span class="p">(</span><span class="nf">factorial</span><span class="w"> </span><span class="nv">n</span><span class="p">)</span>

<span class="w"> </span><span class="p">(</span><span class="nb">*</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="p">(</span><span class="nf">factorial</span><span class="w"> </span><span class="p">(</span><span class="nb">-</span><span class="w"> </span><span class="nv">n</span><span class="w"> </span><span class="mi">1</span><span class="p">)))))</span><span class="w"> </span><span class="c1">;;; n! = n*(n-1)!</span>

</pre></div>

<p>This defines the factorial function using its recursive definition. In contrast, it is more typical to define a procedure for an imperative language.

</p><p>In lisps and lambda calculus, functions are generally <a href="First-class_citizen" title="First-class citizen">first-class citizens</a>. Loosely, this means that functions can be inputs and outputs for other functions. This can simplify the definition of some functions.

</p><p>For example, writing a function to output the first n <a href="Square_number" title="Square number">square numbers</a> in <a href="Racket_(programming_language)" title="Racket (programming language)">Racket</a> can be done accordingly:

</p>

<div class="mw-highlight mw-highlight-lang-scheme mw-content-ltr" dir="ltr"><pre><span class="p">(</span><span class="k">define</span><span class="w"> </span><span class="p">(</span><span class="nf">first-n-squares</span><span class="w"> </span><span class="nv">n</span><span class="p">)</span>

<span class="w"> </span><span class="p">(</span><span class="nb">map</span><span class="w"> </span><span class="p">(</span><span class="k">lambda</span><span class="w"> </span><span class="p">(</span><span class="nf">x</span><span class="p">)</span><span class="w"> </span><span class="p">(</span><span class="nb">*</span><span class="w"> </span><span class="nv">x</span><span class="w"> </span><span class="nv">x</span><span class="p">))</span><span class="w"> </span><span class="c1">;;; A function mapping x -> x^2</span>

<span class="w"> </span><span class="p">(</span><span class="nf">range</span><span class="w"> </span><span class="nv">n</span><span class="p">)))</span><span class="w"> </span><span class="c1">;;; Lists the first n naturals</span>

</pre></div>

<p>The <a href="Map_(higher-order_function)" title="Map (higher-order function)">map</a> function accepts a function and a list; the output is a list of results of the input function on each element of the input list.

</p>

<p><a href="ML_(programming_language)" title="ML (programming language)">ML</a> (1973)<sup id="cite_ref-Gordon1996_9-0" class="reference"><a href="#cite_note-Gordon1996-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> stands for <i>Meta Language</i>. ML is statically typed, and function arguments and return types may be annotated.<sup id="cite_ref-cpl_3rd-ch9-233_10-0" class="reference"><a href="#cite_note-cpl_3rd-ch9-233-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-highlight mw-highlight-lang-sml mw-content-ltr" dir="ltr"><pre><span class="kr">fun</span> <span class="nf">times_10</span><span class="p">(</span><span class="n">n</span> <span class="p">:</span> <span class="n">int</span><span class="p">)</span> <span class="p">:</span> <span class="n">int</span> <span class="p">=</span> <span class="mi">10</span> <span class="n">*</span> <span class="n">n</span><span class="p">;</span>

</pre></div>

<p><i>ML</i> is not as bracket-centric as <i>Lisp</i>, and instead uses a wider variety of syntax to codify the relationship between code elements, rather than appealing to list ordering and nesting to express everything. The following is an application of <code>times_10</code>:

</p>

<pre>times_10 2

</pre>

<p>It returns "20 : int", that is, <code>20</code>, a value of type <code>int</code>.

</p><p>Like <i>Lisp</i>, <i>ML</i> is tailored to process lists, though all elements of a list must be the same type.<sup id="cite_ref-cpl_3rd-ch9-235_11-0" class="reference"><a href="#cite_note-cpl_3rd-ch9-235-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading3"><h3 id="Prolog">Prolog</h3></div>

<p><a href="Prolog" title="Prolog">Prolog</a> (1972) stands for "PROgramming in LOGic." It was developed for natural language <a href="Question_answering" title="Question answering">question answering</a>,<sup id="cite_ref-PrologHistory_12-0" class="reference"><a href="#cite_note-PrologHistory-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup> using SL resolution<sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> both to deduce answers to queries and to parse and generate natural language sentences.

</p><p>The building blocks of a Prolog program are <i>facts</i> and <i>rules</i>. Here is a simple example:

</p>

<span class="nf">mouse</span><span class="p">(</span><span class="s s-Atom">jerry</span><span class="p">).</span> <span class="c1">% jerry is a mouse</span>

<span class="nf">animal</span><span class="p">(</span><span class="nv">X</span><span class="p">)</span> <span class="p">:-</span> <span class="nf">cat</span><span class="p">(</span><span class="nv">X</span><span class="p">).</span> <span class="c1">% each cat is an animal</span>

<span class="nf">animal</span><span class="p">(</span><span class="nv">X</span><span class="p">)</span> <span class="p">:-</span> <span class="nf">mouse</span><span class="p">(</span><span class="nv">X</span><span class="p">).</span> <span class="c1">% each mouse is an animal</span>

<span class="nf">small</span><span class="p">(</span><span class="nv">X</span><span class="p">)</span> <span class="p">:-</span> <span class="nf">mouse</span><span class="p">(</span><span class="nv">X</span><span class="p">).</span> <span class="c1">% each mouse is small</span>

<span class="nf">eat</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span><span class="nv">Y</span><span class="p">)</span> <span class="p">:-</span> <span class="nf">mouse</span><span class="p">(</span><span class="nv">X</span><span class="p">),</span> <span class="nf">cheese</span><span class="p">(</span><span class="nv">Y</span><span class="p">).</span> <span class="c1">% each mouse eats each cheese</span>

<span class="nf">eat</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span><span class="nv">Y</span><span class="p">)</span> <span class="p">:-</span> <span class="nf">big</span><span class="p">(</span><span class="nv">X</span><span class="p">),</span> <span class="nf">small</span><span class="p">(</span><span class="nv">Y</span><span class="p">).</span> <span class="c1">% each big being eats each small being</span>

</pre></div>

<p>Given this program, the query <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">eat</span><span class="p">(</span><span class="s s-Atom">tom</span><span class="p">,</span><span class="s s-Atom">jerry</span><span class="p">)</span></code> succeeds, while <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">eat</span><span class="p">(</span><span class="s s-Atom">jerry</span><span class="p">,</span><span class="s s-Atom">tom</span><span class="p">)</span></code> fails. Moreover, the query <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">eat</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span><span class="s s-Atom">jerry</span><span class="p">)</span></code> succeeds with the answer substitution <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nv">X</span><span class="o">=</span><span class="s s-Atom">tom</span></code>.

</p><p>Prolog executes programs top-down, using <a href="SLD_resolution" title="SLD resolution">SLD resolution</a> to <a href="Backward_chaining" title="Backward chaining">reason backwards</a>, reducing goals to subgoals. In this example, it uses the last rule of the program to reduce the goal of answering the query <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">eat</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span><span class="s s-Atom">jerry</span><span class="p">)</span></code> to the subgoals of first finding an X such that <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">big</span><span class="p">(</span><span class="nv">X</span><span class="p">)</span></code> holds and then of showing that <code class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><span class="nf">small</span><span class="p">(</span><span class="s s-Atom">jerry</span><span class="p">)</span></code> holds. It repeatedly uses rules to further reduce subgoals to other subgoals, until it eventually succeeds in <a href="Unification_(computer_science)#Application:_unification_in_logic_programming" title="Unification (computer science)">unifying</a> all subgoals with facts in the program. This backward reasoning, goal-reduction strategy treats rules in logic programs as procedures, and makes Prolog both a declarative and <a href="Procedural_programming#Logic_programming" title="Procedural programming">procedural programming</a> language.<sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup>

</p><p>The broad range of Prolog applications is highlighted in the Year of Prolog Book,<sup id="cite_ref-Prolog_Book_15-0" class="reference"><a href="#cite_note-Prolog_Book-15"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup> celebrating the 50 year anniversary of Prolog.

</p>

<div class="mw-heading mw-heading3"><h3 id="Datalog">Datalog</h3></div>

<p>The <a href="Datalog#History" title="Datalog">origins of Datalog</a> date back to the beginning of logic programming, but it was identified as a separate area around 1977. <a href="Syntax_and_semantics_of_logic_programming" title="Syntax and semantics of logic programming">Syntactically and semantically</a>, it is a subset of Prolog. But because it lacks <a href="Prolog#Data_types" title="Prolog">compound terms</a>, it is not <a href="Turing_completeness" title="Turing completeness">Turing-complete</a>.

</p><p>Most Datalog systems execute programs bottom-up, using rules to <a href="Forward_chaining" title="Forward chaining">reason forwards</a>, deriving new facts from existing facts, and terminating when there are no new facts that can be derived, or when the derived facts unify with the query. In the above example, a typical Datalog system would first derive the new facts:

</p>

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre><span class="nf">animal</span><span class="p">(</span><span class="s s-Atom">tom</span><span class="p">).</span>

<span class="nf">animal</span><span class="p">(</span><span class="s s-Atom">jerry</span><span class="p">).</span>

<span class="nf">small</span><span class="p">(</span><span class="s s-Atom">jerry</span><span class="p">).</span>

</pre></div>

<p>Using these facts, it would then derive the additional fact:

</p>

<div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre><span class="nf">eats</span><span class="p">(</span><span class="s s-Atom">tom</span><span class="p">,</span> <span class="s s-Atom">jerry</span><span class="p">).</span>

</pre></div><p>

It would then terminate, both because no new, additional facts can be derived, and because the newly derived fact unifies with the query </p><div class="mw-highlight mw-highlight-lang-prolog mw-content-ltr" dir="ltr"><pre><span class="nf">eats</span><span class="p">(</span><span class="nv">X</span><span class="p">,</span> <span class="s s-Atom">jerry</span><span class="p">).</span>

</pre></div>

<p>Datalog has been applied to such problems as <a href="Data_integration" title="Data integration">data integration</a>, <a href="Information_extraction" title="Information extraction">information extraction</a>, <a href="Computer_network" title="Computer network">networking</a>, <a href="Security" title="Security">security</a>, <a href="Cloud_computing" title="Cloud computing">cloud computing</a> and <a href="Machine_learning" title="Machine learning">machine learning</a>.<sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading3"><h3 id="Answer_set_programming">Answer set programming</h3></div>

<p><a href="Answer_set_programming" title="Answer set programming">Answer set programming</a> (ASP) evolved in the late 1990s, based on the <a href="Stable_model_semantics" title="Stable model semantics">stable model</a> (answer set) semantics of logic programming. Like Datalog, it is a subset of Prolog; and, because it lacks compound terms, it is not Turing-complete.

</p><p>Most implementations of ASP execute a program by first <i>grounding</i> the program, replacing all variables in rules by constants in all possible ways, and then using a propositional SAT solver, such as the <a href="DPLL_algorithm" title="DPLL algorithm">DPLL algorithm</a> to generate one or more models of the program.

</p><p>Its applications are oriented towards solving difficult <a href="Search_algorithm" title="Search algorithm">search problems</a> and <a href="Knowledge_representation" class="mw-redirect" title="Knowledge representation">knowledge representation</a>.<sup id="cite_ref-18" class="reference"><a href="#cite_note-18"><span class="cite-bracket">[</span>18<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-19" class="reference"><a href="#cite_note-19"><span class="cite-bracket">[</span>19<span class="cite-bracket">]</span></a></sup>

</p>

<ul><li><a href="Inductive_programming" title="Inductive programming">Inductive programming</a></li>

<li><a href="List_of_programming_languages_by_type#Declarative_languages" title="List of programming languages by type">List of declarative programming languages</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFLloyd" class="citation report cs1">Lloyd, J.W. Practical Advantages of Declarative Programming (Report).</cite></span>

</li>

<li id="cite_note-FOLDOC_2004-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-FOLDOC_2004_2-0">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://foldoc.org/declarative+language">"declarative language"</a>. <i>FOLDOC</i>. 17 May 2004. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20230907151526/https://foldoc.org/declarative+language">Archived</a> from the original on 7 September 2023<span class="reference-accessdate">. Retrieved <span class="nowrap">7 September</span> 2023</span>.</cite></span>

</li>

<li id="cite_note-Sebesta_2016-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-Sebesta_2016_3-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFSebesta2016" class="citation book cs1">Sebesta, Robert (2016). <i>Concepts of programming languages</i>. Boston: Pearson. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-13-394302-3</bdi>. <a href="OCLC_(identifier)" class="mw-redirect" title="OCLC (identifier)">OCLC</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/oclc/896687896">896687896</a>.</cite></span>

</li>

<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/">"Imperative programming: Overview of the oldest programming paradigm"</a>. <i>IONOS Digital Guide</i>. 2021-05-21. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/">Archived</a> from the original on 2022-05-03<span class="reference-accessdate">. Retrieved <span class="nowrap">2023-05-23</span></span>.</cite></span>

</li>

<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/">"DAMP 2009: Workshop on Declarative Aspects of Multicore Programming"</a>. Cse.unsw.edu.au. 20 January 2009. Archived from <a rel="nofollow" class="external text" href="http://www.cse.unsw.edu.au/~pls/damp09/">the original</a> on 13 September 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">15 August</span> 2013</span>.</cite></span>

</li>

<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite id="CITEREFChakravarty1997" class="citation thesis cs1">Chakravarty, Manuel M. T. (14 February 1997). <a rel="nofollow" class="external text" href="http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz"><i>On the Massively Parallel Execution of Declarative Programs</i></a> (Doctoral dissertation). <a href="Technische_Universit%C3%A4t_Berlin" title="Technische Universität Berlin">Technische Universität Berlin</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150923211531/http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz">Archived</a> from the original on 23 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">26 February</span> 2015</span>. <q>In this context, the criterion for calling a programming language declarative is the existence of a clear, mathematically established correspondence between the language and mathematical logic such that a declarative semantics for the language can be based on the model or the proof theory (or both) of the logic.</q></cite></span>

</li>

<li id="cite_note-7"><span class="mw-cite-backlink"><b><a href="#cite_ref-7">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20071023021126/http://phoenix.labri.fr/wiki/doku.php?id=an_overview_on_dsls">"An overview on dsls"</a>. Archived from <a rel="nofollow" class="external text" href="http://phoenix.labri.fr/wiki/doku.php?id=an_overview_on_dsls">the original</a> on October 23, 2007.</cite></span>

</li>

<li id="cite_note-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-8">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.simulistics.com/tour/declarative.htm">"Declarative modelling"</a>. Simulistics. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20030811073949/http://www.simulistics.com/tour/declarative.htm">Archived</a> from the original on 11 August 2003<span class="reference-accessdate">. Retrieved <span class="nowrap">15 August</span> 2013</span>.</cite></span>

</li>

<li id="cite_note-Gordon1996-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-Gordon1996_9-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFGordon1996" class="citation web cs1"><a href="Michael_J._C._Gordon" title="Michael J. C. Gordon">Gordon, Michael J. C.</a> (1996). <a rel="nofollow" class="external text" href="http://www.cl.cam.ac.uk/~mjcg/papers/HolHistory.html">"From LCF to HOL: a short history"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160905201847/http://www.cl.cam.ac.uk/~mjcg/papers/HolHistory.html">Archived</a> from the original on 2016-09-05<span class="reference-accessdate">. Retrieved <span class="nowrap">2021-10-30</span></span>.</cite></span>

</li>

<li id="cite_note-cpl_3rd-ch9-233-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-cpl_3rd-ch9-233_10-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFWilson2001" class="citation book cs1">Wilson, Leslie B. (2001). <i>Comparative Programming Languages, Third Edition</i>. Addison-Wesley. p. 233. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-201-71012-9</bdi>.</cite></span>

</li>

<li id="cite_note-cpl_3rd-ch9-235-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-cpl_3rd-ch9-235_11-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFWilson2001" class="citation book cs1">Wilson, Leslie B. (2001). <i>Comparative Programming Languages, Third Edition</i>. Addison-Wesley. p. 235. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-201-71012-9</bdi>.</cite></span>

</li>

<li id="cite_note-PrologHistory-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-PrologHistory_12-0">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://alain.colmerauer.free.fr/alcol/ArchivesPublications/PrologHistory/19november92.pdf">"Birth of Prolog"</a> <span class="cs1-format">(PDF)</span>. November 1992. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150402111123/http://alain.colmerauer.free.fr/alcol/ArchivesPublications/PrologHistory/19november92.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 2015-04-02<span class="reference-accessdate">. Retrieved <span class="nowrap">2022-05-25</span></span>.</cite></span>

</li>

<li id="cite_note-13"><span class="mw-cite-backlink"><b><a href="#cite_ref-13">^</a></b></span> <span class="reference-text"><cite id="CITEREFRobert_KowalskiDonald_Kuehner1971" class="citation journal cs1">Robert Kowalski; Donald Kuehner (Winter 1971). <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/sl.pdf">"Linear Resolution with Selection Function"</a> <span class="cs1-format">(PDF)</span>. <i>Artificial Intelligence</i>. <b>2</b> (<span class="nowrap">3–</span>4): <span class="nowrap">227–</span>260. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1016%2F0004-3702%2871%2990012-9">10.1016/0004-3702(71)90012-9</a>. <a href="ISSN_(identifier)" class="mw-redirect" title="ISSN (identifier)">ISSN</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/issn/0004-3702">0004-3702</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150923215814/http://www.doc.ic.ac.uk/~rak/papers/sl.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 2015-09-23<span class="reference-accessdate">. Retrieved <span class="nowrap">2023-08-13</span></span>.</cite></span>

</li>

<li id="cite_note-14"><span class="mw-cite-backlink"><b><a href="#cite_ref-14">^</a></b></span> <span class="reference-text">Robert Kowalski <a rel="nofollow" class="external text" href="http://www.doc.ic.ac.uk/~rak/papers/IFIP%2074.pdf">Predicate Logic as a Programming Language</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160207012437/http://www.doc.ic.ac.uk/~rak/papers/IFIP%2074.pdf">Archived</a> 2016-02-07 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> Memo 70, Department of Artificial Intelligence, University of Edinburgh. 1973. Also in Proceedings IFIP Congress, Stockholm, North Holland Publishing Co., 1974, pp. 569-574.</span>

</li>

<li id="cite_note-Prolog_Book-15"><span class="mw-cite-backlink"><b><a href="#cite_ref-Prolog_Book_15-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFWarren2023" class="citation book cs1">Warren, D.S. (2023). "Introduction to Prolog". In Warren, D.S.; Dahl, V.; Eiter, T.; Hermenegildo, M.V.; Kowalski, R.; Rossi, F. (eds.). <i>Prolog: The Next 50 Years</i>. Lecture Notes in Computer Science (LNCS). Vol. 13900. Springer, Cham. pp. <span class="nowrap">3–</span>19. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F978-3-031-35254-6_1">10.1007/978-3-031-35254-6_1</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-3-031-35253-9</bdi>.</cite></span>

</li>

<li id="cite_note-16"><span class="mw-cite-backlink"><b><a href="#cite_ref-16">^</a></b></span> <span class="reference-text"><cite id="CITEREFHuangGreenLoo2011" class="citation conference cs1">Huang, Shan Shan; Green, Todd J.; Loo, Boon Thau (June 12–16, 2011). <a rel="nofollow" class="external text" href="http://www.cs.ucdavis.edu/~green/papers/sigmod906t-huang.pdf"><i>Datalog and Emerging applications</i></a> <span class="cs1-format">(PDF)</span>. SIGMOD 2011. Athens, Greece: Association for Computing Machinery. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4503-0661-4</bdi>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20201022234145/https://www.cs.ucdavis.edu/~green/papers/sigmod906t-huang.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 2020-10-22<span class="reference-accessdate">. Retrieved <span class="nowrap">2023-08-13</span></span>.</cite></span>

</li>

<li id="cite_note-17"><span class="mw-cite-backlink"><b><a href="#cite_ref-17">^</a></b></span> <span class="reference-text"><cite id="CITEREFMeiQinXuEisner2020" class="citation conference cs1">Mei, Hongyuan; Qin, Guanghui; Xu, Minjie; Eisner, Jason (2020). "Neural Datalog Through Time: Informed Temporal Modeling via Logical Specification". <i>Proceedings of ICML 2020</i>. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://arxiv.org/abs/2006.16723">2006.16723</a></span>.</cite></span>

</li>

<li id="cite_note-18"><span class="mw-cite-backlink"><b><a href="#cite_ref-18">^</a></b></span> <span class="reference-text"><cite id="CITEREFBaral2003" class="citation book cs1">Baral, Chitta (2003). <span class="id-lock-registration" title="Free registration required"><a rel="nofollow" class="external text" href="https://archive.org/details/knowledgereprese00bara"><i>Knowledge Representation, Reasoning and Declarative Problem Solving</i></a></span>. Cambridge University Press. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-521-81802-5</bdi>.</cite></span>

</li>

<li id="cite_note-19"><span class="mw-cite-backlink"><b><a href="#cite_ref-19">^</a></b></span> <span class="reference-text"><cite id="CITEREFGelfond2008" class="citation book cs1">Gelfond, Michael (2008). <a rel="nofollow" class="external text" href="https://books.google.com/books?id=xwBDylHhJhYC&pg=PA285">"Answer sets"</a>. In van Harmelen, Frank; Lifschitz, Vladimir; Porter, Bruce (eds.). <i>Handbook of Knowledge Representation</i>. Elsevier. pp. <span class="nowrap">285–</span>316. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-08-055702-1</bdi>.</cite> <a rel="nofollow" class="external text" href="http://www.depts.ttu.edu/cs/research/krlab/pdfs/papers/gel07b.pdf">as PDF</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160303231241/http://www.depts.ttu.edu/cs/research/krlab/pdfs/papers/gel07b.pdf">Archived</a> 2016-03-03 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li>Frans Coenen. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060424045449/http://www.csc.liv.ac.uk/~frans/OldLectures/2CS24/declarative.html#detail">Characteristics of declarative programming languages</a>. 1999.</li>

<li><a href="Robert_Harper_(computer_scientist)" title="Robert Harper (computer scientist)">Robert Harper</a>.

<ul><li><a rel="nofollow" class="external text" href="https://existentialtype.wordpress.com/2013/07/18/what-if-anything-is-a-declarative-language/">What, If Anything, Is A Declarative Language?</a>. 2013.</li>

<li>"<a rel="nofollow" class="external text" href="https://existentialtype.wordpress.com/2013/07/22/there-is-such-a-thing-as-a-declarative-language/">There Is Such A Thing As A Declarative Language, and It's The World's Best DSL</a>". 2013.</li></ul></li>

<li>Olof Torgersson. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060330033506/http://www.cs.chalmers.se/~oloft/Papers/wm96/wm96.html">A Note on Declarative Programming Paradigms and the Future of Definitional Programming</a>. 1996.</li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>

<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>

<li><a href="Modular_programming" title="Modular programming">Modular</a></li>

<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>

<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>

<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>

<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>

<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>

<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a><br>(<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>

<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>

<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>

<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a><br>(<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>

<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>

<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>

<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>

<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>

<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>

<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>

<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>

<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>

<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>

<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>

<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>

<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>

<li><a href="Stream_processing" title="Stream processing">Streams</a></li>

<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Logic_programming" title="Logic programming">Logic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>

<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>

<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>

<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>

<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>

<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>

<li><a href="Query_language" title="Query language">Query</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>

<li><a href="Array_programming" title="Array programming">Array</a></li>

<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>

<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>

<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>

<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>

<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>

<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>

<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>

<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>

<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>

<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>

<li><a href="Page_description_language" title="Page description language">Page description</a></li>

<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>

<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>

<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>

<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>

<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>

<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>

<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>

<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>

<li><a href="System_programming_language" title="System programming language">System</a></li>

<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>

<li><a href="Template_processor" title="Template processor">Templating</a></li>

<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>

<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Concurrent_computing" title="Concurrent computing">Concurrent</a>,<br><a href="Distributed_computing" title="Distributed computing">distributed</a>,<br><a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>

<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>

<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>

<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>

<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>

<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>

<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>

<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>

<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>

<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>

<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>

<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>

<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>

<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>

<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>

<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>

<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>

<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>

<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>

<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>

<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>

<li><a href="Reflective_programming" title="Reflective programming">Reflective</a></li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>

<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation<br>of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Aspect-oriented_programming" title="Aspect-oriented programming">Aspects</a></li>

<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>

<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>

<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>

<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>

<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>

<li><a href="Literate_programming" title="Literate programming">Literate</a></li>

<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>

<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Types_of_programming_languages107" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Types_of_programming_languages107" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Types of programming languages</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Level</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Machine_code" title="Machine code">Machine</a></li>

<li><a href="Assembly_language" title="Assembly language">Assembly</a></li>

<li><a href="Compiled_language" title="Compiled language">Compiled</a></li>

<li><a href="Interpreted_language" class="mw-redirect" title="Interpreted language">Interpreted</a></li></ul>

<ul><li><a href="Low-level_programming_language" title="Low-level programming language">Low-level</a></li>

<li><a href="High-level_programming_language" title="High-level programming language">High-level</a></li>

<li><a href="Very_high-level_programming_language" title="Very high-level programming language">Very high-level</a></li>

<li><a href="Esoteric_programming_language" title="Esoteric programming language">Esoteric</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_generations" title="Programming language generations">Generation</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="First-generation_programming_language" title="First-generation programming language">First</a></li>

<li><a href="Second-generation_programming_language" title="Second-generation programming language">Second</a></li>

<li><a href="Third-generation_programming_language" title="Third-generation programming language">Third</a></li>

<li><a href="Fourth-generation_programming_language" title="Fourth-generation programming language">Fourth</a></li>

<li><a href="Fifth-generation_programming_language" title="Fifth-generation programming language">Fifth</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox authority-control" aria-labelledby="Authority_control_databases_frameless&#124;text-top&#124;10px&#124;alt=Edit_this_at_Wikidata&#124;link=https&#58;//www.wikidata.org/wiki/Q531152#identifiers&#124;class=noprint&#124;Edit_this_at_Wikidata976" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Authority_control_databases_frameless&#124;text-top&#124;10px&#124;alt=Edit_this_at_Wikidata&#124;link=https&#58;//www.wikidata.org/wiki/Q531152#identifiers&#124;class=noprint&#124;Edit_this_at_Wikidata976" style="font-size:114%;margin:0 4em">Authority control databases </div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">National</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><span class="uid"><a rel="nofollow" class="external text" href="https://d-nb.info/gnd/4293503-9">Germany</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://id.loc.gov/authorities/sh93000071">United States</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb123495726">France</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://data.bnf.fr/ark:/12148/cb123495726">BnF data</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://datos.bne.es/resource/XX538968">Spain</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://www.nli.org.il/en/authorities/987007544381005171">Israel</a></span></li></ul></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><span class="uid"><a rel="nofollow" class="external text" href="https://lux.collections.yale.edu/view/concept/b73bb2bc-6234-484b-9d57-3c0faa1fecb3">Yale LUX</a></span></li></ul></div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-16" href="https://en.wikipedia.org/wiki/?title=Declarative_programming&oldid=1300802428">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>